/**
 * 替换项目中的控制台日志为 logger 工具
 * 使用方法: node scripts/replace-console-logs.js
 */

const fs = require('fs');
const path = require('path');
const { promisify } = require('util');

const readdir = promisify(fs.readdir);
const stat = promisify(fs.stat);
const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);

// 需要处理的文件扩展名
const FILE_EXTENSIONS = ['.js', '.vue', '.ts', '.jsx', '.tsx'];

// 需要排除的目录
const EXCLUDE_DIRS = ['node_modules', 'dist', '.git', 'public'];

// 替换规则
const REPLACEMENTS = [
  {
    pattern: /console\.log\((.*?)\);/g,
    replacement: "logger.log($1);"
  },
  {
    pattern: /console\.error\((.*?)\);/g,
    replacement: "logger.error($1);"
  },
  {
    pattern: /console\.warn\((.*?)\);/g,
    replacement: "logger.warn($1);"
  },
  {
    pattern: /console\.info\((.*?)\);/g,
    replacement: "logger.info($1);"
  },
  {
    pattern: /console\.debug\((.*?)\);/g,
    replacement: "logger.debug($1);"
  }
];

// 导入检查
const IMPORT_CHECK = "import logger from '@/utils/logger';";
const IMPORT_PATTERN = /import\s+.*\s+from\s+['"].*['"]/g;

/**
 * 检查文件是否需要处理
 * @param {string} filePath 文件路径
 * @returns {boolean} 是否需要处理
 */
function shouldProcessFile(filePath) {
  const ext = path.extname(filePath);
  return FILE_EXTENSIONS.includes(ext);
}

/**
 * 处理单个文件
 * @param {string} filePath 文件路径
 */
async function processFile(filePath) {
  try {
    // 读取文件内容
    const content = await readFile(filePath, 'utf8');
    
    // 检查是否有控制台日志
    let hasConsoleLog = false;
    for (const { pattern } of REPLACEMENTS) {
      if (pattern.test(content)) {
        hasConsoleLog = true;
        break;
      }
    }
    
    if (!hasConsoleLog) {
      return; // 没有控制台日志，不需要处理
    }
    
    // 替换控制台日志
    let newContent = content;
    for (const { pattern, replacement } of REPLACEMENTS) {
      newContent = newContent.replace(pattern, replacement);
    }
    
    // 检查是否已经导入 logger
    const hasLoggerImport = newContent.includes("import logger from '@/utils/logger'");
    
    // 如果没有导入 logger，添加导入语句
    if (!hasLoggerImport) {
      // 找到第一个 import 语句
      const importMatches = newContent.match(IMPORT_PATTERN);
      if (importMatches && importMatches.length > 0) {
        const firstImport = importMatches[0];
        newContent = newContent.replace(firstImport, `${firstImport}\n${IMPORT_CHECK}`);
      } else {
        // 如果没有 import 语句，在文件开头添加
        newContent = `${IMPORT_CHECK}\n\n${newContent}`;
      }
    }
    
    // 写入文件
    await writeFile(filePath, newContent, 'utf8');
    console.log(`处理文件: ${filePath}`);
  } catch (error) {
    console.error(`处理文件 ${filePath} 失败:`, error);
  }
}

/**
 * 递归处理目录
 * @param {string} dirPath 目录路径
 */
async function processDirectory(dirPath) {
  try {
    const entries = await readdir(dirPath);
    
    for (const entry of entries) {
      const entryPath = path.join(dirPath, entry);
      
      // 检查是否是排除的目录
      if (EXCLUDE_DIRS.includes(entry)) {
        continue;
      }
      
      const entryStat = await stat(entryPath);
      
      if (entryStat.isDirectory()) {
        // 递归处理子目录
        await processDirectory(entryPath);
      } else if (entryStat.isFile() && shouldProcessFile(entryPath)) {
        // 处理文件
        await processFile(entryPath);
      }
    }
  } catch (error) {
    console.error(`处理目录 ${dirPath} 失败:`, error);
  }
}

/**
 * 主函数
 */
async function main() {
  const srcDir = path.join(__dirname, '..', 'src');
  console.log(`开始处理目录: ${srcDir}`);
  await processDirectory(srcDir);
  console.log('处理完成!');
}

main().catch(error => {
  console.error('脚本执行失败:', error);
  process.exit(1);
});